Базовые конструкции и основные элементы языка C++ и Qt

Содержание лекции

• Переменные и типы данных
• Преобразование и приведение типов
• Динамическая инициализация
• Область действия и время жизни переменных
• Циклы и логические конструкции
• Массивы и строки
• Особенности Qt-типов

Переменные и типы данных в C++

// Целочисленные типы
int counter = 42;           // 32-битное целое
long long bigNumber = 1234567890LL;  // 64-битное целое
unsigned int positive = 100;         // Беззнаковое целое

// Типы с плавающей точкой
float pi = 3.14f;           // 32-битное число
double precise = 3.14159265359;     // 64-битное число

// Символьные типы
char symbol = 'A';          // Один символ
wchar_t wideChar = L'Б';    // Широкий символ
char16_t utf16 = u'ю';      // UTF-16 символ
char32_t utf32 = U'';     // UTF-32 символ

// Логический тип
bool isConnected = true;    // true или false

Квалификаторы типов

// Квалификатор const - неизменяемость
const int MAX_CONNECTIONS = 100;
const double PI = 3.14159;

// Квалификатор constexpr - константа времени компиляции
constexpr int BUFFER_SIZE = 1024;
constexpr double EULER_NUMBER = 2.71828;

// Квалификатор volatile - запрет оптимизации
volatile bool dataReady = false;  // Может измениться вне программы

// Квалификатор mutable - возможность изменения в const-методах
class NetworkBuffer {
private:
    mutable int accessCount = 0;
    
public:
    void process() const {
        accessCount++;  // Допустимо благодаря mutable
    }
};

Пользовательские типы данных

// Перечисления (enum) — имена попадают в общую область видимости
enum ConnectionState {
    DISCONNECTED,
    CONNECTING,
    CONNECTED,
    ERROR_STATE
};

// Перечисления с областью видимости (enum class) — рекомендуется
enum class ProtocolType {
    TCP,
    UDP,
    HTTP,
    WebSocket
};

// Структуры (struct)
struct NetworkPacket {
    int packetId;
    std::string data;
    time_t timestamp;
};

// Объединения (union) — в современном C++ лучше использовать std::variant
union DataValue {
    int integer;
    float floating;
    char string[8];
};

Преобразование типов в C++

Неявное преобразование (автоматическое)

int x = 10;
double y = x;           // Неявное преобразование int -> double
char c = 'A';
int code = c;           // Неявное преобразование char -> int

// Потеря точности
double precise = 3.14159;
int truncated = precise;  // 3 (дробная часть отбрасывается)

Явное преобразование (приведение типов)

// Старый стиль C — избегать!
int oldStyle = (int)3.14;

// Новый стиль C++ — предпочитать
double value = 3.14;
int cast1 = static_cast<int>(value);        // Безопасное приведение
int* ptr = nullptr;
void* voidPtr = reinterpret_cast<void*>(ptr);  // Приведение указателей

// Приведение const
const int constValue = 42;
int* nonConst = const_cast<int*>(&constValue);  // Удаление const

// Приведение с проверкой (для полиморфных типов)
class Base { virtual void foo() {} };
class Derived : public Base { void bar() {} };

Base* base = new Derived();
Derived* derived = dynamic_cast<Derived*>(base);  // Проверка времени выполнения

Расширение типов (Type Promotion)

// Автоматическое расширение в выражениях
short s1 = 10, s2 = 20;
int result = s1 + s2;    // short расширяется до int

// Правила расширения
char c = 'A';
int i = 50;
float f = 1.5f;

auto sum = c + i + f;    // char -> int -> float

// Расширение в функциях
void processValue(int value) { /* ... */ }

short shortValue = 100;
processValue(shortValue);  // Автоматическое расширение short -> int

Динамическая инициализация

Инициализация переменных

// Прямая инициализация
int port(8080);
std::string server("localhost");

// Список инициализации (C++11) — рекомендуется
int bufferSize{4096};
double timeout{30.5};

// Автоматический вывод типа (C++11)
auto portNumber = 8080;        // int
auto serverName = "localhost"; // const char*
auto piValue = 3.14159;        // double

// Инициализация nullptr (C++11)
int* pointer = nullptr;        // Современный способ обозначения нулевого указателя

Инициализация в Qt

#include <QString>
#include <QVector>
#include <QMap>

// Инициализация QString
QString message = "Hello, Qt!";
QString emptyString;  // Пустая строка

// Инициализация контейнеров Qt
QVector<int> numbers = {1, 2, 3, 4, 5};  // Список инициализации
QMap<QString, int> settings = {
    {"timeout", 30},
    {"retries", 3},
    {"port", 8080}
};

// Инициализация сетевых классов Qt
#include <QHostAddress>
QHostAddress localHost("127.0.0.1");
QHostAddress anyAddress = QHostAddress::Any;

Область действия переменных (Scope)

Глобальная область видимости

// Глобальные переменные — минимизировать использование!
int globalConnectionCount = 0;
const int MAX_BUFFER_SIZE = 4096;

// Пространство имен — предпочтительный способ организации
namespace NetworkConfig {
    const std::string DEFAULT_HOST = "localhost";
    const int DEFAULT_PORT = 8080;
}

void function() {
    std::cout << NetworkConfig::DEFAULT_HOST << std::endl;
}

Локальная область видимости

void processData() {
    int localCounter = 0;  // Локальная переменная
    
    if (true) {
        int blockScoped = 42;  // Область видимости - блок if
        localCounter = blockScoped;
    }
    // blockScoped недоступен здесь
    
    for (int i = 0; i < 10; i++) {
        // i доступен только внутри цикла
        localCounter += i;
    }
    // i недоступен здесь
}

Время жизни переменных (Lifetime)

Автоматическое время жизни

void function() {
    int autoVariable = 10;  // Создается при входе в блок
    // ... использование переменной
}  // Уничтожается при выходе из блока — вызывается деструктор

Статическое время жизни

void counterFunction() {
    static int callCount = 0;  // Инициализируется один раз
    callCount++;
    std::cout << "Function called " << callCount << " times" << std::endl;
}

class NetworkServer {
private:
    static int instanceCount;  // Статический член класса
    // ...
};

// Определение вне класса
int NetworkServer::instanceCount = 0;

Динамическое время жизни

// Ручное управление — избегать в современном C++!
int* dynamicArray = new int[100];
for (int i = 0; i < 100; i++) {
    dynamicArray[i] = i * i;
}
delete[] dynamicArray;  // Забыли — утечка памяти

// Современный подход: умные указатели (C++11)
#include <memory>
auto smartArray = std::make_unique<int[]>(100);  // Авто-освобождение
smartArray[0] = 8080;

// Для совместного владения
auto sharedData = std::make_shared<NetworkPacket>();

Условные конструкции

Оператор if-else

int checkConnectionStatus(int port) {
    if (port < 0 || port > 65535) {
        return -1;  // Неверный порт
    } else if (port < 1024) {
        return 0;   // Системный порт (requires root/Admin)
    } else {
        return 1;   // Пользовательский порт
    }
}

// Тернарный оператор
std::string getStatus(bool isConnected) {
    return isConnected ? "Connected" : "Disconnected";
}

Оператор switch

std::string getProtocolName(int protocol) {
    switch (protocol) {
        case 6:
            return "TCP";
        case 17:
            return "UDP";
        case 80:
            return "HTTP";
        case 443:
            return "HTTPS";
        default:
            return "Unknown";
    }
}

// Switch с несколькими case
std::string getServiceType(int port) {
    switch (port) {
        case 21: case 22: case 23:
            return "Remote Access";
        case 25: case 587:
            return "Email";
        case 80: case 443: case 8080:
            return "Web Service";
        default:
            return "Other";
    }
}

Циклы в C++

Цикл for

// Классический for
for (int i = 0; i < 10; i++) {
    std::cout << "Iteration: " << i << std::endl;
}

// For с несколькими переменными
for (int i = 0, j = 10; i < j; i++, j--) {
    std::cout << i << " " << j << std::endl;
}

// Бесконечный цикл
for (;;) {
    if (condition) break;
    // ...
}

// Диапазонный for (C++11) — предпочтительный способ
std::vector<int> ports = {80, 443, 8080, 3000};
for (int port : ports) {
    std::cout << "Port: " << port << std::endl;
}

Цикл while

// Предусловный цикл — тело может не выполниться ни разу
int attempts = 0;
while (attempts < 3 && !isConnected) {
    connectToServer();
    attempts++;
}

// Паттерн retry с экспоненциальной задержкой
int retries = 0;
while (retries < MAX_RETRIES) {
    if (tryConnect()) break;
    std::this_thread::sleep_for(std::chrono::milliseconds(100 * (1 << retries)));
    retries++;
}

Цикл do-while

// Постусловный цикл — тело выполняется хотя бы один раз
char choice;
do {
    std::cout << "Continue? (y/n): ";
    std::cin >> choice;
} while (choice == 'y' || choice == 'Y');

// Меню с гарантированным первым выполнением
int option;
do {
    showMenu();
    std::cin >> option;
    processMenuOption(option);
} while (option != 0);

Управление циклами

// Оператор break - выход из цикла
for (int port = 1; port <= 65535; port++) {
    if (isPortOpen(port)) {
        std::cout << "Found open port: " << port << std::endl;
        break;  // Выход при первом найденном открытом порте
    }
}

// Оператор continue - переход к следующей итерации
std::vector<int> ports = {21, 22, 80, 443, 8080, 3306};
for (int port : ports) {
    if (isPortReserved(port)) {
        continue;  // Пропустить зарезервированные порты
    }
    scanPort(port);
}

// Выход из вложенных циклов через флаг (C++ не поддерживает break label)
bool found = false;
for (int i = 0; i < 10 && !found; i++) {
    for (int j = 0; j < 10; j++) {
        if (i * j > 50) {
            found = true;  // Флаг для выхода из внешнего цикла
            break;         // Выход из внутреннего цикла
        }
    }
}

Массивы в C++

Статические массивы

// Одномерные массивы
int ports[5] = {80, 443, 8080, 3000, 9000};
char message[] = "Hello, Network!";  // Автоматический размер = 16 (с \0)

// Двумерные массивы
int matrix[3][3] = {
    {1, 2, 3},
    {4, 5, 6},
    {7, 8, 9}
};

// Массивы без инициализации
int buffer[1024];  // Содержит мусор!
int zeros[256] = {0};  // Все элементы = 0

// Предпочтительный вариант (C++11)
#include <array>
std::array<int, 5> safePorts = {80, 443, 8080, 3000, 9000};

Работа с массивами

// Доступ к элементам
int firstPort = ports[0];      // 80 — без проверки границ
int lastPort = ports[4];       // 9000

// Безопасный доступ через std::array
int safe = safePorts.at(0);    // Бросает std::out_of_range

// Изменение элементов
ports[2] = 8888;  // Заменить 8080 на 8888

// Перебор массива
for (int i = 0; i < 5; i++) {
    std::cout << "Port " << i << ": " << ports[i] << std::endl;
}

// Ошибка: выход за границы — НЕПРЕДСКАЗУЕМОЕ ПОВЕДЕНИЕ!
// int invalid = ports[10];  // UB: может упасть, а может и нет

Динамические массивы

// Raw new[] — избегать в современном коде
int* dynamicPorts = new int[10];
for (int i = 0; i < 10; i++) {
    dynamicPorts[i] = 1000 + i * 100;
}
std::cout << "Port 5: " << dynamicPorts[5] << std::endl;  // 1500
delete[] dynamicPorts;  // Забыли delete[] — утечка памяти!

// Современный подход: std::vector — предпочтительный выбор
#include <vector>
std::vector<int> ports = {80, 443, 8080};
ports.push_back(3000);   // Автоматическое управление памятью
ports.resize(100);       // Изменение размера
// Освобождение — автоматически при выходе из области видимости

Строки в C++

C-style строки

// Создание C-строк — избегать в новом коде!
char cString1[] = "Network";
char cString2[20] = "Programming";
const char* cString3 = "C++";

// Работа с C-строками
#include <cstring>
char buffer[50];
strcpy(buffer, "Hello ");          // Нет проверки переполнения!
strcat(buffer, "World");           // Нет проверки переполнения!
int length = strlen(buffer);

// Безопасные альтернативы
strncpy(buffer, "Hello", sizeof(buffer) - 1);
strncat(buffer, " World", sizeof(buffer) - strlen(buffer) - 1);

C++ строки (std::string)

#include <string>

// Создание строк
std::string str1 = "Network";
std::string str2("Programming");
std::string str3 = str1 + " " + str2;  // "Network Programming"

// Методы строк
int len = str1.length();          // Длина
char first = str1[0];            // Первый символ
std::string sub = str1.substr(0, 4);  // "Netw"

// Поиск и замена
size_t pos = str3.find("Prog");
if (pos != std::string::npos) {
    str3.replace(pos, 4, "Development");
}

// Преобразование чисел
int port = 8080;
std::string portStr = std::to_string(port);
int portNum = std::stoi(portStr);

QString в Qt

#include <QString>
#include <QDebug>

// Создание QString
QString qtString1 = "Qt Network";
QString qtString2 = QString("Programming");
QString qtString3 = qtString1 + " " + qtString2;

// Преобразования
std::string stdStr = qtString3.toStdString();
const char* cStr = qtString3.toLocal8Bit().constData();

// Форматирование (аналог sprintf)
QString formatted = QString("Server %1:%2 is %3")
                   .arg("localhost")
                   .arg(8080)
                   .arg("running");

// Работа с Unicode
QString unicode = QString::fromUtf8("Привет, мир!");
QString fromStd = QString::fromStdString("C++ string");

// Полезные методы
bool startsWith = qtString1.startsWith("Qt");
bool endsWith = qtString1.endsWith("Network");
QString upper = qtString1.toUpper();
QString lower = qtString1.toLower();

Контейнеры Qt для массивов

#include <QVector>
#include <QList>
#include <QMap>
#include <QHash>

// QVector - динамический массив (в Qt 6 QList = QVector)
QVector<int> ports;
ports.append(80);
ports.append(443);
ports << 8080 << 3000;  // Оператор <<

int first = ports.first();    // 80
int last = ports.last();      // 3000

// QList - список (оптимизирован для Qt)
QList<QString> protocols;
protocols << "TCP" << "UDP" << "HTTP";

// QMap - ассоциативный массив (отсортированный)
QMap<QString, int> portMap;
portMap["HTTP"] = 80;
portMap["HTTPS"] = 443;

// QHash - хеш-таблица (быстрее, но не отсортирована)
QHash<QString, int> fastPortMap;
fastPortMap["FTP"] = 21;

Современные особенности C++11 и выше

// Автоматический вывод типа
auto port = 8080;                    // int
auto server = "localhost";           // const char*
auto config = NetworkConfig("srv", 80);  // NetworkConfig

// Универсальная инициализация
int ports[] = {80, 443, 8080};
std::vector<int> portsVec{80, 443, 8080};
std::map<std::string, int> settings{
    {"timeout", 30},
    {"retries", 3}
};

// nullptr вместо NULL
int* pointer = nullptr;  // Безопасный нулевой указатель

// Range-based for с const auto&
std::vector<std::string> protocols = {"TCP", "UDP", "HTTP"};
for (const auto& proto : protocols) {
    std::cout << proto << std::endl;
}

Заключение

Основные концепции:

• Переменные и типы — фундамент любой программы
• Преобразование типов — важно для предотвращения ошибок
• Область видимости и время жизни — критичны для управления ресурсами
• Циклы и условия — управление потоком выполнения
• Массивы и строки — основы работы с данными
• Qt-типы — расширение возможностей стандартных типов

Рекомендации:

• Используйте современные конструкции C++11+ (auto, nullptr, range-for)
• Предпочитайте std::string и QString C-строкам
• Используйте std::vector / std::array вместо C-массивов
• Управляйте памятью через умные указатели (RAII)
• Следите за областью видимости — объявляйте переменные минимально
• В Qt используйте QString для Unicode и Qt-контейнеры для совместимости

Вопросы для самопроверки

1. Чем отличаются const и constexpr?
2. Какие существуют способы приведения типов в C++?
3. В чём различие между std::string и QString?
4. Как управлять временем жизни динамически выделенных объектов?
5. Когда использовать QVector, а когда QList?
6. Что такое области видимости и как они влияют на доступ к переменным?
7. Какие преимущества даёт использование диапазонных циклов?
8. Почему в C++ нет labeled break и как выйти из вложенных циклов?